Dec29, 2025

Cómo integrar DrissionPage con CapSolver para una resolución de CAPTCHA sin interrupciones

Adélia Cruz

Neural Network Developer

1. Introducción

La automatización web se ha vuelto esencial para la recopilación de datos, las pruebas y diversas operaciones empresariales. Sin embargo, los sitios web modernos implementan medidas anti-bot sofisticadas y CAPTCHAs que pueden detener incluso los scripts de automatización más cuidadosamente elaborados.

La combinación de DrissionPage y CapSolver proporciona una solución poderosa para este desafío:

DrissionPage: Una herramienta de automatización web basada en Python que controla navegadores Chromium sin necesidad de WebDriver, combinando la automatización del navegador con solicitudes HTTP
CapSolver: Un servicio de resolución de CAPTCHA impulsado por inteligencia artificial que maneja Cloudflare Turnstile, reCAPTCHA y más

Juntos, estos herramientas permiten una automatización web fluida que evita la detección de WebDriver y los desafíos de CAPTCHA.

1.1. Objetivos de la integración

Este guía te ayudará a lograr tres objetivos principales:

Evitar la detección de WebDriver - Usar el control nativo del navegador de DrissionPage sin firmas de Selenium/WebDriver
Resolver CAPTCHAs automáticamente - Integrar la API de CapSolver para manejar desafíos de CAPTCHA sin intervención manual
Mantener un comportamiento humano - Combinar cadenas de acciones con resolución inteligente de CAPTCHA

2. ¿Qué es DrissionPage?

DrissionPage es una herramienta de automatización web basada en Python que combina el control del navegador con capacidades de solicitudes HTTP. A diferencia de Selenium, utiliza un kernel desarrollado por sí mismo que no depende de WebDriver, lo que lo hace más difícil de detectar.

2.1. Características clave

No se requiere WebDriver - Controla navegadores Chromium de forma nativa sin chromedriver
Operación en modo dual - Combinar automatización del navegador (modo d) con solicitudes HTTP (modo s)
Localización de elementos simplificada - Sintaxis intuitiva para encontrar elementos
Navegación cruzada de iframes - Localizar elementos en iframes sin cambiar
Soporte para múltiples pestañas - Operar múltiples pestañas simultáneamente
Cadenas de acciones - Encadenar acciones de ratón y teclado
Esperas integradas - Mecanismos de reintentos automáticos para redes inestables

2.2. Instalación

bash Copy

# Instalar DrissionPage
pip install DrissionPage

# Instalar biblioteca requests para la API de CapSolver
pip install requests

2.3. Uso básico

python Copy

from DrissionPage import ChromiumPage

# Crear instancia del navegador
page = ChromiumPage()

# Navegar a la URL
page.get('https://wikipedia.org')

# Encontrar e interactuar con elementos
page('#search-input').input('Hello World')
page('#submit-btn').click()

3. ¿Qué es CapSolver?

CapSolver es un servicio de resolución automática de CAPTCHA impulsado por inteligencia artificial que admite una amplia gama de tipos de CAPTCHA. Proporciona una API simple que le permite enviar desafíos de CAPTCHA y recibir soluciones en segundos.

3.1. Tipos de CAPTCHA admitidos

Cloudflare Turnstile - El desafío anti-bot más común moderno
Cloudflare Challenge
reCAPTCHA v2 - Variantes basadas en imágenes e invisibles
reCAPTCHA v3 - Verificación basada en puntuación
AWS WAF - CAPTCHA de Amazon Web Services
Y muchos más...

3.2. Comenzar con CapSolver

Regístrese en capsolver.com
Agregue fondos a su cuenta
Obtenga su clave de API desde el panel de control

3.3. Puntos finales de la API

Servidor A: https://api.capsolver.com
Servidor B: https://api-stable.capsolver.com

4. Desafíos previos a la integración

Antes de combinar DrissionPage con CapSolver, la automatización web enfrentaba varios problemas:

Desafío	Impacto
Detección de WebDriver	Los scripts de Selenium se bloquean inmediatamente
Desafíos de CAPTCHA	Se requiere resolución manual, rompiendo la automatización
Complejidad de iframes	Difícil interactuar con contenido anidado
Operaciones de múltiples pestañas	Se requiere lógica compleja de cambio de pestaña

La integración de DrissionPage + CapSolver resuelve todos estos desafíos en un solo flujo de trabajo.

5. Métodos de integración

5.1. Integración de API (Recomendado)

El método de integración de API le da control total sobre el proceso de resolución de CAPTCHA y funciona con cualquier tipo de CAPTCHA.

5.1.1. Requisitos de configuración

bash Copy

pip install DrissionPage requests

5.1.2. Patrón de integración principal

python Copy

import time
import requests
from DrissionPage import ChromiumPage

CAPSOLVER_API_KEY = "SU_CLAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


def create_task(task_payload: dict) -> str:
    """Crear una tarea de resolución de CAPTCHA y devolver el ID de la tarea."""
    response = requests.post(
        f"{CAPSOLVER_API}/createTask",
        json={
            "clientKey": CAPSOLVER_API_KEY,
            "task": task_payload
        }
    )
    result = response.json()
    if result.get("errorId") != 0:
        raise Exception(f"Error de CapSolver: {result.get('errorDescription')}")
    return result["taskId"]


def get_task_result(task_id: str, max_attempts: int = 120) -> dict:
    """Consultar el resultado de la tarea hasta que se resuelva o expire el tiempo."""
    for _ in range(max_attempts):
        response = requests.post(
            f"{CAPSOLVER_API}/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        )
        result = response.json()

        if result.get("status") == "ready":
            return result["solution"]
        elif result.get("status") == "failed":
            raise Exception(f"Tarea fallida: {result.get('errorDescription')}")

        time.sleep(1)

    raise TimeoutError("El tiempo de resolución de CAPTCHA se agotó")


def solve_captcha(task_payload: dict) -> dict:
    """Flujo de trabajo completo para resolver CAPTCHA."""
    task_id = create_task(task_payload)
    return get_task_result(task_id)

5.2. Extensión del navegador

También puede usar la extensión de CapSolver con DrissionPage para un enfoque más pasivo.

5.2.1. Pasos de instalación

Descargue la extensión de CapSolver desde capsolver.com/en/extension
Extraiga los archivos de la extensión
Configure su clave de API en el archivo config.js de la extensión:

javascript Copy

// En la carpeta de la extensión, edite: assets/config.js
var defined = {
    apiKey: "SU_CLAVE_DE_API_DE_CAPSOLVER",  // Reemplazar con su clave de API real
    enabledForBlacklistControl: false,
    blackUrlList: [],
    enabledForRecaptcha: true,
    enabledForRecaptchaV3: true,
    enabledForTurnstile: true,
    // ... otros ajustes
}

Cargue la extensión en DrissionPage:

python Copy

from DrissionPage import ChromiumPage, ChromiumOptions

co = ChromiumOptions()
co.add_extension('/ruta/a/capsolver-extension')

page = ChromiumPage(co)
# La extensión detectará y resolverá automáticamente los CAPTCHA

Nota: La extensión debe tener una clave de API válida configurada antes de poder resolver CAPTCHA automáticamente.

6. Ejemplos de código

6.1. Resolviendo Cloudflare Turnstile

Cloudflare Turnstile es uno de los desafíos de CAPTCHA más comunes. Así es como lo resuelves:

python Copy

import time
import requests
from DrissionPage import ChromiumPage

CAPSOLVER_API_KEY = "SU_CLAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


def solve_turnstile(site_key: str, page_url: str) -> str:
    """Resolver Cloudflare Turnstile y devolver el token."""
    # Crear la tarea
    response = requests.post(
        f"{CAPSOLVER_API}/createTask",
        json={
            "clientKey": CAPSOLVER_API_KEY,
            "task": {
                "type": "AntiTurnstileTaskProxyLess",
                "websiteURL": page_url,
                "websiteKey": site_key,
            }
        }
    )
    result = response.json()

    if result.get("errorId") != 0:
        raise Exception(f"Error: {result.get('errorDescription')}")

    task_id = result["taskId"]

    # Consultar el resultado
    while True:
        result = requests.post(
            f"{CAPSOLVER_API}/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        ).json()

        if result.get("status") == "ready":
            return result["solution"]["token"]
        elif result.get("status") == "failed":
            raise Exception(f"Falló: {result.get('errorDescription')}")

        time.sleep(1)


def main():
    target_url = "https://tu-sitio-objetivo.com"
    turnstile_site_key = "0x4XXXXXXXXXXXXXXXXX"  # Encontrar esto en el código de la página

    # Crear instancia del navegador
    page = ChromiumPage()
    page.get(target_url)

    # Esperar a que se cargue Turnstile
    page.wait.ele_displayed('input[name="cf-turnstile-response"]', timeout=10)

    # Resolver el CAPTCHA
    token = solve_turnstile(turnstile_site_key, target_url)
    print(f"Obtenido token de Turnstile: {token[:50]}...")

    # Inyectar el token usando JavaScript
    page.run_js(f'''
        document.querySelector('input[name="cf-turnstile-response"]').value = "{token}";

        // También activar el callback si está presente
        const callback = document.querySelector('[data-callback]');
        if (callback) {{
            const callbackName = callback.getAttribute('data-callback');
            if (window[callbackName]) {{
                window[callbackName]('{token}');
            }}
        }}
    ''')

    # Enviar el formulario
    page('button[type="submit"]').click()
    page.wait.load_start()

    print("¡Turnstile evadido con éxito!")


if __name__ == "__main__":
    main()

6.2. Resolviendo reCAPTCHA v2 (Detección automática de clave del sitio)

Este ejemplo detecta automáticamente la clave del sitio desde la página - no se necesita configuración manual:

python Copy

import time
import requests
from DrissionPage import ChromiumPage, ChromiumOptions

CAPSOLVER_API_KEY = "SU_CLAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


def solve_recaptcha_v2(site_key: str, page_url: str) -> str:
    """Resolver reCAPTCHA v2 y devolver el token."""
    # Crear la tarea
    response = requests.post(
        f"{CAPSOLVER_API}/createTask",
        json={
            "clientKey": CAPSOLVER_API_KEY,
            "task": {
                "type": "ReCaptchaV2TaskProxyLess",
                "websiteURL": page_url,
                "websiteKey": site_key,
            }
        }
    )
    result = response.json()

    if result.get("errorId") != 0:
        raise Exception(f"Error: {result.get('errorDescription')}")

    task_id = result["taskId"]
    print(f"Tarea creada: {task_id}")

    # Consultar el resultado
    while True:
        result = requests.post(
            f"{CAPSOLVER_API}/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        ).json()

        if result.get("status") == "ready":
            return result["solution"]["gRecaptchaResponse"]
        elif result.get("status") == "failed":
            raise Exception(f"Falló: {result.get('errorDescription')}")

        time.sleep(1)


def main():
    # Solo proporcionar la URL - la clave del sitio se detectará automáticamente
    target_url = "https://www.google.com/recaptcha/api2/demo"

    # Configurar el navegador
    co = ChromiumOptions()
    co.set_argument('--disable-blink-features=AutomationControlled')

    print("Iniciando navegador...")
    page = ChromiumPage(co)

    try:
        page.get(target_url)
        time.sleep(2)

        # Detectar automáticamente la clave del sitio desde la página
        recaptcha_div = page('.g-recaptcha')
        if not recaptcha_div:
            print("¡No se encontró reCAPTCHA en la página!")
            return

        site_key = recaptcha_div.attr('data-sitekey')
        print(f"Clave del sitio detectada automáticamente: {site_key}")

        # Resolver el CAPTCHA
        print("Resolviendo reCAPTCHA v2...")
        token = solve_recaptcha_v2(site_key, target_url)
        print(f"Obtenido token: {token[:50]}...")

        # Inyectar el token
        page.run_js(f'''
            var responseField = document.getElementById('g-recaptcha-response');
            responseField.style.display = 'block';
            responseField.value = '{token}';
        ''')
        print("¡Token inyectado!")

        # Enviar el formulario
        submit_btn = page('#recaptcha-demo-submit') or page('input[type="submit"]') or page('button[type="submit"]')
        if submit_btn:
            submit_btn.click()
            time.sleep(3)
            print("¡Formulario enviado!")

        print(f"URL actual: {page.url}")
        print("¡ÉXITO!")

    finally:
        page.quit()


if __name__ == "__main__":
    main()

Pruébalo tú mismo:

bash Copy

python recaptcha_demo.py

Esto abrirá la página de demostración de reCAPTCHA de Google, detectará automáticamente la clave del sitio, resolverá el CAPTCHA y enviará el formulario.

6.3. Resolviendo reCAPTCHA v3

reCAPTCHA v3 es basado en puntuación y no requiere interacción del usuario. Debe especificar el parámetro de acción.

python Copy

import time
import requests
from DrissionPage import ChromiumPage, ChromiumOptions

CAPSOLVER_API_KEY = "SU_CLAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


def solve_recaptcha_v3(
    site_key: str,
    page_url: str,
    action: str = "verify",
    min_score: float = 0.7
) -> str:
    """Resolver reCAPTCHA v3 con la acción especificada y la puntuación mínima."""
    response = requests.post(
        f"{CAPSOLVER_API}/createTask",
        json={
            "clientKey": CAPSOLVER_API_KEY,
            "task": {
                "type": "ReCaptchaV3TaskProxyLess",
                "websiteURL": page_url,
                "websiteKey": site_key,
                "pageAction": action,
                "minScore": min_score
            }
        }
    )
    result = response.json()

    if result.get("errorId") != 0:
        raise Exception(f"Error: {result.get('errorDescription')}")

    task_id = result["taskId"]

    while True:
        result = requests.post(
            f"{CAPSOLVER_API}/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        ).json()

        if result.get("status") == "ready":
            return result["solution"]["gRecaptchaResponse"]
        elif result.get("status") == "failed":
            raise Exception(f"Falló: {result.get('errorDescription')}")

        time.sleep(1)


def main():
    target_url = "https://tu-sitio-objetivo.com"
    recaptcha_v3_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"

    # Configurar navegador en modo headless para v3
    co = ChromiumOptions()
    co.headless()

    page = ChromiumPage(co)
    page.get(target_url)

    # Resolver reCAPTCHA v3 con acción "search"
    print("Resolviendo reCAPTCHA v3...")
    token = solve_recaptcha_v3(
        recaptcha_v3_key,
        target_url,
        action="search",
        min_score=0.9  # Solicitar alta puntuación
    )

    # Ejecutar el callback con el token
    page.run_js(f'''
        // Si hay una función de callback, llámela con el token
        if (typeof onRecaptchaSuccess === 'function') {{
            onRecaptchaSuccess('{token}');
}}
        // O establecer el valor del campo oculto
        var responseField = document.querySelector('[name="g-recaptcha-response"]');
        if (responseField) {{
            responseField.value = '{token}';
        }}
    ''')

    print("¡Bypass de reCAPTCHA v3 completado!")


if __name__ == "__main__":
    main()

6.4. Uso de cadenas de acciones para comportamiento humano

DrissionPage proporciona cadenas de acciones para movimientos de mouse y interacciones de teclado naturales:

python Copy

import time
import random
from DrissionPage import ChromiumPage
from DrissionPage.common import Keys, Actions

def human_delay():
    """Retardo aleatorio para imitar el comportamiento humano."""
    time.sleep(random.uniform(0.5, 1.5))

def main():
    page = ChromiumPage()
    page.get('https://your-target-site.com/form')

    # Usar cadenas de acciones para interacciones humanas
    ac = Actions(page)

    # Moverse al campo de entrada de manera natural, luego hacer clic y escribir
    ac.move_to('input[name="email"]').click()
    human_delay()

    # Escribir lentamente como un humano
    for char in "user@email.com":
        ac.type(char)
        time.sleep(random.uniform(0.05, 0.15))

    human_delay()

    # Moverse al campo de contraseña
    ac.move_to('input[name="password"]').click()
    human_delay()

    # Escribir contraseña
    page('input[name="password"]').input("mypassword123")

    # Después de resolver la CAPTCHA, hacer clic en enviar con movimiento natural
    ac.move_to('button[type="submit"]')
    human_delay()
    ac.click()

if __name__ == "__main__":
    main()

7. Buenas prácticas

7.1. Configuración del navegador

Configura DrissionPage para que parezca un navegador regular:

python Copy

from DrissionPage import ChromiumPage, ChromiumOptions

co = ChromiumOptions()
co.set_argument('--disable-blink-features=AutomationControlled')
co.set_argument('--no-sandbox')
co.set_user_agent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36')

# Establecer el tamaño de la ventana a una resolución común
co.set_argument('--window-size=1920,1080')

page = ChromiumPage(co)

7.2. Modo incógnito y modo sin cabeza

python Copy

from DrissionPage import ChromiumPage, ChromiumOptions

co = ChromiumOptions()
co.incognito()  # Usar modo incógnito
co.headless()   # Ejecutar en modo sin cabeza (para CAPTCHAs v3)

page = ChromiumPage(co)

7.3. Limitación de tasas

Evita activar limitaciones de tasas añadiendo retardos aleatorios:

python Copy

import random
import time

def human_delay(min_sec=1.0, max_sec=3.0):
    """Retardo aleatorio para imitar el comportamiento humano."""
    time.sleep(random.uniform(min_sec, max_sec))

# Usar entre acciones
page('#button1').click()
human_delay()
page('#input1').input('texto')

7.4. Manejo de errores

Siempre implementa manejo de errores adecuado para resolver CAPTCHAs:

python Copy

def solve_with_retry(task_payload: dict, max_retries: int = 3) -> dict:
    """Resolver CAPTCHA con lógica de reintentos."""
    for attempt in range(max_retries):
        try:
            return solve_captcha(task_payload)
        except TimeoutError:
            if attempt < max_retries - 1:
                print(f"Tiempo de espera agotado, reintentando... ({attempt + 1}/{max_retries})")
                time.sleep(5)
            else:
                raise
        except Exception as e:
            if "balance" in str(e).lower():
                raise  # No reintentar errores de balance
            if attempt < max_retries - 1:
                time.sleep(2)
            else:
                raise

7.5. Soporte de proxy

Usa proxies con DrissionPage para rotar IPs:

python Copy

from DrissionPage import ChromiumPage, ChromiumOptions

co = ChromiumOptions()
co.set_proxy('http://username:password@proxy.example.com:8080')

page = ChromiumPage(co)

8. Conclusión

La integración de DrissionPage y CapSolver crea una herramienta poderosa para automatización web:

DrissionPage maneja la automatización del navegador sin firmas de detección de WebDriver
CapSolver resuelve CAPTCHAs con resolución basada en IA
Juntos permiten automatización fluida que parece completamente humana

Ya sea que estés construyendo scrapers web, sistemas de pruebas automatizadas o pipelines de recolección de datos, esta combinación proporciona la confiabilidad y el disfraz que necesitas.

Bonus: Usa el código DRISSION al registrarte en CapSolver para recibir créditos adicionales!

9. Preguntas frecuentes

9.1. ¿Por qué elegir DrissionPage sobre Selenium?

DrissionPage no usa WebDriver, lo que significa:

No es necesario descargar/actualizar chromedriver
Evita firmas comunes de detección de WebDriver
API más sencilla con esperas integradas
Mejor rendimiento y uso de recursos
Soporte nativo para localización de elementos en iframes

9.2. ¿Qué tipos de CAPTCHA funcionan mejor con esta integración?

CapSolver soporta todos los tipos principales de CAPTCHA. Turnstile de Cloudflare y reCAPTCHA v2/v3 tienen las tasas de éxito más altas. La integración funciona de manera fluida con cualquier CAPTCHA que soporte CapSolver.

9.3. ¿Puedo usar esto en modo sin cabeza?

Sí. DrissionPage soporta modo sin cabeza. En modo sin cabeza funciona perfectamente para reCAPTCHA v3 y CAPTCHAs basados en tokens. Para CAPTCHAs v2 visibles, el modo con cabeza puede dar mejores resultados.

9.4. ¿Cómo encuentro la clave del sitio para una CAPTCHA?

Busca en el código fuente de la página:

Turnstile: atributo data-sitekey o elementos cf-turnstile
reCAPTCHA: atributo data-sitekey en el div g-recaptcha

9.5. ¿Qué hacer si la resolución de CAPTCHA falla?

Soluciones comunes:

Verifica tu clave de API y balance
Asegúrate de que la clave del sitio sea correcta
Comprueba que la URL de la página coincida con donde aparece la CAPTCHA
Para v3, prueba ajustar el parámetro de acción y el puntaje mínimo
Implementa lógica de reintentos con retardo

9.6. ¿Puede DrissionPage manejar DOM sombra?

Sí. DrissionPage tiene soporte integrado para elementos del DOM sombra a través de la clase ChromiumShadowElement.

Ver más

web scrapingApr 22, 2026

Arquitectura de raspado de web para extracción de datos escalable

Aprende una arquitectura de raspado web escalable en Rust con reqwest, scraper, raspado asíncrono, raspado con navegador sin cabeza, rotación de proxies y manejo de CAPTCHA conforme.

Aloísio Vítor

web scrapingFeb 17, 2026

Cómo resolver Captcha en Nanobot con CapSolver

Automatiza la resolución de CAPTCHA con Nanobot y CapSolver. Utiliza Playwright para resolver reCAPTCHA y Cloudflare autónomamente.